package com.since.algorithm.stack;

import java.util.Stack;

/**
 * Created by Sincerity on 2020/5/9.
 * 描述： 栈的中缀表达式 计算字符串
 */
class CalculationString {
    /**
     * 1.定义两个栈，一个是数栈，另外是一个符号栈
     * 2.设置优先级别的判断，乘除优先级要大于加减优先级
     * 3.定义一个函数，处理两个操作数和一个运算符的运算符的运算结果
     * 4.逐个扫描输入的中缀表达式，如果是数字就入数栈，如果是运算符的话就考虑其与符号栈顶的运算符的优先级谁的比较高，如果是运算符优先级高于栈顶的话，符号直接入栈，否则，取符号栈栈顶元素出栈与数栈出栈的两个数做运算，结果存入数栈，之后再把运算符入栈。
     * 5.如此往复直到，直到扫描完整个字符串
     * 6.最后要改进的是要注意数字的连续性，设置一个字符串keepnum来获取连续的数字，但是要注意的是获取到数字后字符串要清空，除此之外还要注意数组的越界问题。
     *
     * @param args
     */
    public static void main(String[] args) {
        String s = "1*2-3/4+5*6-7*8+9/10"; //1*2-3/4+5*6-7*8+9/10
        s = s.replaceAll("\\s+", "");
        Stack<Integer> stack = new Stack<>();
        int num1, res = 0;
        char ch;
        String num;
        for (int i = 0; i < s.length(); i++) {
            ch = s.substring(i, i + 1).charAt(0);
            //是数字
            if (!isOper(ch)) {
                num = "";
                for (int j = i; j < s.length(); j++) {
                    char c1 = s.substring(j, j + 1).charAt(0);
                    if (c1 >= 48 && c1 <= 57) {
                        num += c1;
                    } else {//1+1/1
                        break;
                    }
                }
                stack.push(Integer.parseInt(num));
            } else {
                if (i < s.length() - 1) {
                    int next = s.substring(i + 1, i + 2).charAt(0) - 48;
                    switch (ch) {
                        case '+':
                            stack.push(next);
                            break;
                        case '-':
                            stack.push(-(next));
                            break;
                        case '*':
                            num1 = stack.pop();
                            stack.push(num1 * next);
                            break;
                        case '/':
                            num1 = stack.pop();
                            stack.push(  num1 / next);
                            break;
                        default:
                            break;
                    }
                    i++;
                }
            }
        }
        while (!stack.isEmpty()) {
            int result = stack.pop();
            res = result + res;
        }
        System.out.printf("最后结果:+%d", res);
    }


    /**
     * 判断是否是字符串还是数字
     *
     * @param val
     * @return
     */
    static boolean isOper(char val) {
        return val == '+' || val == '-' || val == '*' || val == '/';
    }

    /**
     * 判断优先级
     *
     * @param oper
     * @return
     */
    static int priority(char oper) {
        if (oper == '+' || oper == '-') {
            return 0;
        } else if (oper == '*' || oper == '/') {
            return 1;
        } else {
            return -1;
        }
    }

    /**
     * 运算
     *
     * @param num1 数字1
     * @param num2 数字2
     * @param oper 运算符
     * @return 返回值
     */
    static int Operation(int num1, int num2, char oper) {
        int res = 0;
        switch (oper) {
            case '+':
                res = num1 + num2;
                break;
            case '-':
                res = num1 - num2;
                break;
            case '*':
                res = num1 * num2;
                break;
            case '/':
                res = num1 / num2;
                break;
        }
        return res;
    }

}